package controlador;

import java.util.Vector;

import modelo.Producto;
import modelo.Factura;
import modelo.Tipo;
import modelo.itemFactura;
import modelo.FacturaDTO;
import modelo.TipoDTO;
import modelo.ProductoDTO;
import modelo.itemFacturaDTO;

public class Supermercado {

	private Vector<Producto> productos;
	private Vector<Tipo> tipos;
	private Vector<Factura> facturas;
	private Factura facTemp;

	public ProductoDTO crearProducto(String descripcion, float precio,
			int cantidad, Tipo tip) {

		Producto prod = buscarProducto(descripcion);
		if (prod == null) {
			prod = new Producto(descripcion, precio, cantidad, tip);
			productos.addElement(prod);
			this.agregarProductoToTipo(prod);
		}
		return prod.crearProductoDTO();

	}

	private void agregarProductoToTipo(Producto p) {

		for (int i = 0; i < tipos.size(); i++) {
			System.out.println(tipos.elementAt(i).getDescripcion() + " "
					+ p.getTipoProd().getDescripcion());
			if (this.tipos.elementAt(i).getDescripcion()
					.equals(p.getTipoProd().getDescripcion())) {
				this.tipos.elementAt(i).agregarProducto(p);
			}
		}
	}

	public Producto buscarProducto(String descripcion) {
		for (int i = 0; i < productos.size(); i++) {
			if (productos.elementAt(i).esProducto(descripcion)) {

				return productos.elementAt(i);
			}
		}
		return null;
	}

	public void listarProductos() {
		for (int i = 0; i < productos.size(); i++) {
			ProductoDTO vistaProd = productos.elementAt(i).crearProductoDTO();

			System.out.println("PRODUCTO");
			System.out.println("Codigo: " + vistaProd.getCodProducto());
			System.out.println("Descripcion: " + vistaProd.getDescripcion());
			System.out.println("Tipo:"
					+ vistaProd.getTipoProd().getDescripcion());
			System.out.println("Precio Unitario: $"
					+ vistaProd.getPrecioUnitario());
			System.out.println("Stock: " + vistaProd.getStock());

		}
	}

	public void listarTipo() {
		for (int i = 0; i < tipos.size(); i++) {
			TipoDTO vistaTipo = tipos.elementAt(i).crearTipoDTO();

			System.out.println("TIPO");
			System.out.println("Codigo: " + vistaTipo.getIdTipo());
			System.out.println("Descripcion: " + vistaTipo.getDescripcion());

		}
	}

	public Supermercado() {
		this.productos = new Vector<Producto>();
		this.tipos = new Vector<Tipo>();
		this.setFacturas(new Vector<Factura>());
		this.setFacTemp(null);

		// carga automatica
		crearTipo("Lacteos");
		crearTipo("Limpieza");
		crearTipo("Carniceria");
		crearTipo("Bebidas");
		crearTipo("Almacen");
		crearProducto("Leche", (float) 9.5, 50, tipos.elementAt(0));
		crearProducto("Queso", (float) 5.5, 1000, tipos.elementAt(0));
		crearProducto("Manteca", (float) 7.59, 50, tipos.elementAt(0));
		crearProducto("Coca Cola 1.5L", (float) 11.70, 50, tipos.elementAt(3));
		crearProducto("Agua Sin Gas 1.5L", (float) 9.70, 50, tipos.elementAt(3));
		crearProducto("Hamburguesa cacera", (float) 3.70, 150,tipos.elementAt(2));
		crearProducto("Pollo", (float) 9.70, 150, tipos.elementAt(2));
		crearProducto("Peceto", (float) 60.70, 150, tipos.elementAt(2));
		crearProducto("Lomo Kg", (float) 80.70, 20, tipos.elementAt(2));
		crearProducto("Galletitas agua", (float) 2.70, 150, tipos.elementAt(4));
		crearProducto("Galletitas dulce", (float) 3.20, 150, tipos.elementAt(4));
		crearProducto("Azucar", (float) 6.67, 150, tipos.elementAt(4));
		crearFacturaTemp();
		crearVenta(productos.elementAt(0),2);
		crearVenta(productos.elementAt(1),5);
		crearVenta(productos.elementAt(2),12);
		crearVenta(productos.elementAt(3),5);
		crearVenta(productos.elementAt(4),1);
	}

	private void crearVenta(Producto p, int cant) {
		ingresarItemToFactura(p,cant);	
	}

	public Vector<Producto> getProducto() {
		return productos;
	}

	public void setProducto(Vector<Producto> producto) {
		this.productos = producto;
	}

	public Vector<Tipo> getTipos() {
		return tipos;
	}

	public void setTipos(Vector<Tipo> tipos) {
		this.tipos = tipos;
	}

	public TipoDTO crearTipo(String desc) {
		Tipo tip = buscarTipo(desc);

		if (tip == null) {
			tip = new Tipo(desc);
			this.tipos.addElement(tip);
			return tip.crearTipoDTO();
		}
		return null;
	}

	public Tipo buscarTipo(String desc) {
		for (int i = 0; i < tipos.size(); i++) {
			if (tipos.elementAt(i).esTipo(desc)) {
				return tipos.elementAt(i);
			}
		}
		return null;
	}

	public Tipo buscarTipoXcod(int cod) {
		for (int i = 0; i < tipos.size(); i++) {
			if (tipos.elementAt(i).getIdTipo() == cod) {
				return tipos.elementAt(i);
			}
		}
		return null;
	}

	public void listarProductosPorTipo() {
		for (int i = 0; i < tipos.size(); i++) {
			System.out.println("------------------------------");
			System.out.println(" TIPO " + tipos.elementAt(i).getDescripcion());
			System.out.println("------------------------------");
			Vector<Producto> pro = new Vector<Producto>();
			pro = tipos.elementAt(i).getProductos();
			System.out.println("Cantidad de elementos: " + pro.size());
			ProductoDTO pr;
			for (int j = 0; j < pro.size(); j++) {
				pr = pro.elementAt(j).crearProductoDTO();
				System.out.println("Codigo Producto: " + pr.getCodProducto());
				System.out.println("Descripcion Producto: "
						+ pr.getDescripcion());
				System.out.println("Precio Producto: $"
						+ pr.getPrecioUnitario());
				System.out
						.println("------------------------------------------");

			}
		}
	}

	public Vector<Factura> getFacturas() {
		return facturas;
	}

	public void setFacturas(Vector<Factura> facturas) {
		this.facturas = facturas;
	}

	public void crearFacturaTemp() {
		this.setFacTemp(new Factura());
		System.out.println("Factura Numero: "
				+ this.getFacTemp().getIdFactura());
	}

	public Factura getFacTemp() {
		return facTemp;
	}

	public void setFacTemp(Factura facTemp) {
		this.facTemp = facTemp;
	}

	public Producto buscarProductoXcodigo(float codProd) {
		for (int i = 0; i < productos.size(); i++) {
			if (productos.elementAt(i).esProductoXcodigo(codProd)) {

				return productos.elementAt(i);
			}
		}
		return null;
	}

	public boolean ingresarItemToFactura(Producto p, int can) {
		if (p.getStock() >= can) {
			itemFactura f = new itemFactura(can, p.getDescripcion(),
					p.getPrecioUnitario());
			this.facTemp.agregarItem(f);
			actualizarStockProducto(p.getDescripcion(), can);
			return true;
		}
		return false;
	}

	public void listarFactura() {
		FacturaDTO f = this.facTemp.crearFacturaDTO();
		System.out
				.println("------------------------------------------------------------");
		System.out.println("Factura numero: " + f.getIdFactura());
		System.out
				.println("------------------------------------------------------------");
		Vector<itemFacturaDTO> items = f.getItems();

		for (int i = 0; i < items.size(); i++) {
			System.out.println("Item: Cantidad: "
					+ items.elementAt(i).getCantidad() + " Descripcion: "
					+ items.elementAt(i).getDescripcion()
					+ " Precio Unitario: "
					+ items.elementAt(i).getPrecioUnitario() + " Total: "
					+ items.elementAt(i).getCantidad()*items.elementAt(i).getPrecioUnitario());
		}
		System.out
				.println("------------------------------------------------------------");
		System.out.println("TOTAL: " + f.getTotal());
		System.out
				.println("------------------------------------------------------------");

	}

	public void cerrarVenta() {
		Vector<itemFactura> f = this.facTemp.getItems();
		float total = 0;
		for (int i = 0; i < f.size(); i++) {
			total = total + f.elementAt(i).getCantidad()*f.elementAt(i).getPrecioUnitario();
			//actualizarStockProducto(f.elementAt(i).getDescripcion(), f.elementAt(i).getCantidad());
		}
		this.facTemp.setTotal(total);
		facturas.add(this.facTemp);
		listarFactura();
		crearFacturaTemp();
	}

	private void actualizarStockProducto(String desc, int cant) {
		Producto p= buscarProducto(desc);
		if(p!=null){
			p.setStock(p.getStock()-cant);
		}
	}

	public boolean eliminarTipo(int cod) {
		for (int i = 0; i < tipos.size(); i++) {
			if (tipos.elementAt(i).getIdTipo() == cod) {
				Vector<Producto> p = tipos.elementAt(i).getProductos();
				for (int j = 0; j < p.size(); j++) {
					eliminarProductosPorTipo(tipos.elementAt(i).getIdTipo());
					p.remove(j);
				}
				tipos.remove(i);
				return true;
			}
		}
		return false;
	}

	private void eliminarProductosPorTipo(int codTipo) {
		for (int k = 0; k < productos.size(); k++) {
			if (productos.elementAt(k).getTipoProd().getIdTipo() == codTipo) {
				productos.remove(k);
			}
		}
	}

	public Vector<TipoDTO> getTiposDTO() {
		Vector<TipoDTO> vecDTO = new Vector<TipoDTO>();

		for (int i = 0; i < tipos.size(); i++) {
			TipoDTO tDTO = tipos.elementAt(i).crearTipoDTO();
			vecDTO.add(tDTO);
		}
		return vecDTO;
	}

	public boolean eliminarProducto(float cod) {

		for (int i = 0; i < productos.size(); i++) {
			if (productos.elementAt(i).getCodProducto() == cod) {
				eliminarProductoDeTipo(cod, productos.elementAt(i)
						.getTipoProd().getIdTipo());
				productos.remove(i);
				return true;
			}
		}
		return false;
	}

	private void eliminarProductoDeTipo(float codProd, int idTipo) {
		Vector<Producto> vProd;
		for (int i = 0; i < tipos.size(); i++) {
			if (tipos.elementAt(i).getIdTipo() == idTipo) {
				vProd = tipos.elementAt(i).getProductos();
				for (int j = 0; j < vProd.size(); j++) {
					if (vProd.elementAt(j).getCodProducto() == codProd) {
						vProd.remove(j);
					}
				}
			}
		}
	}

	public Vector<ProductoDTO> getProductoDTO() {
		Vector<ProductoDTO> pDTO = new Vector<ProductoDTO>();
		for (int i = 0; i < productos.size(); i++) {
			pDTO.add(productos.elementAt(i).crearProductoDTO());
		}
		return pDTO;
	}

	public boolean modificarProducto(float codProd, String desc, int stock,
			float prec, String tipo) {
		Producto p = this.buscarProductoXcodigo(codProd);
		if (p != null) {
			p.setDescripcion(desc);
			p.setPrecioUnitario(prec);
			p.setStock(stock);
			p.setTipoProd(this.buscarTipo(tipo));
			return true;
		}
		return false;
	}

}